home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / MPW_TOOL / TOOLS / TOOLS_WI / FAST_LEX / SCAN_C.DIS < prev    next >
Text File  |  1988-07-04  |  39KB  |  1,373 lines
  1. #define YY_DEFAULT_ACTION YY_FATAL_ERROR( "flex scanner jammed" );
  2. #define FLEX_USE_ECS
  3. #define FLEX_USE_MECS
  4. /* A lexical scanner generated by flex */
  5.  
  6. #include "flexskeldef.h"
  7.  
  8. # line 1 "scan.l"
  9. #define INITIAL 0
  10. /* scan.l - scanner for flex input */
  11. /*
  12.  * Copyright (c) 1987, the University of California
  13.  * 
  14.  * The United States Government has rights in this work pursuant to
  15.  * contract no. DE-AC03-76SF00098 between the United States Department of
  16.  * Energy and the University of California.
  17.  * 
  18.  * This program may be redistributed.  Enhancements and derivative works
  19.  * may be created provided the new works, if made available to the general
  20.  * public, are made available for use by anyone.
  21.  */
  22. # line 16 "scan.l"
  23. #include "flexdef.h"
  24. #include "parse.h"
  25.  
  26. #define ACTION_ECHO fprintf( temp_action_file, "%s", yytext )
  27. #define MARK_END_OF_PROLOG fprintf( temp_action_file, "%%%% end of prolog\n" );
  28.  
  29. #undef YY_DECL
  30. #define YY_DECL \
  31.     int flexscan()
  32.  
  33. #define RETURNCHAR \
  34.     yylval = yytext[0] & BYTEMASK; \
  35.     return ( CHAR );
  36.  
  37. #define RETURNNAME \
  38.     (void) strcpy( nmstr, yytext ); \
  39.     return ( NAME );
  40.  
  41. #define PUT_BACK_STRING(str, start) \
  42.     for ( i = strlen( str ) - 1; i >= start; --i ) \
  43.         unput(str[i])
  44. #define SECT2 2
  45. #define SECT2PROLOG 4
  46. #define SECT3 6
  47. #define CODEBLOCK 8
  48. #define PICKUPDEF 10
  49. #define SC 12
  50. #define CARETISBOL 14
  51. #define NUM 16
  52. #define QUOTE 18
  53. #define FIRSTCCL 20
  54. #define CCL 22
  55. #define ACTION 24
  56. #define RECOVER 26
  57. #define BRACEERROR 28
  58. #define C_COMMENT 30
  59. #define C_COMMENT_2 32
  60. #define ACTION_COMMENT 34
  61. #define ACTION_STRING 36
  62. #define PERCENT_BRACE_ACTION 38
  63. # line 53 "scan.l"
  64. #define YY_JAM 226
  65. #define YY_JAM_BASE 800
  66. #define YY_TEMPLATE 227
  67. static char l[227] =
  68.     {   0,
  69.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  70.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  71.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  72.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  73.        14,    7,   13,   11,    7,   12,   14,   14,   14,   10,
  74.        46,   39,   40,   32,   46,   45,   30,   46,   46,   46,
  75.        39,   28,   46,   45,   31,    0,   27,   99,    0,   21,
  76.         0,   23,   22,   24,   52,   48,   49,   51,   53,   67,
  77.        68,   65,   64,   66,   54,   56,   55,   54,   60,   59,
  78.        60,   60,   62,   62,   62,   63,   76,   80,   79,   81,
  79.  
  80.        81,   74,   75,    0,   25,   70,   69,   17,   19,   18,
  81.        89,   91,   90,   83,   85,   84,   92,   94,   95,   96,
  82.        72,   72,   73,   72,    7,   11,    0,    7,    1,    0,
  83.         2,    0,    8,    4,    5,    0,    3,   10,   39,   40,
  84.         0,    0,   35,    0,    0,   97,   97,    0,   34,   33,
  85.        34,    0,   39,   28,    0,    0,    0,   42,   38,   26,
  86.         0,   23,   50,   51,   64,   98,   98,    0,   57,   58,
  87.        61,   76,    0,   78,    0,   77,   15,   87,   83,   82,
  88.        92,   93,   71,    1,    0,    9,    8,    0,    0,    6,
  89.        36,    0,   37,   43,    0,    0,   97,   34,   34,   44,
  90.  
  91.        29,    0,   36,    0,   29,    0,   42,    0,   20,   98,
  92.         0,   16,    0,   88,   71,    0,    0,   97,   98,    0,
  93.         0,   97,   98,    4,    0,    0
  94.     } ;
  95. /*
  96.  * Two things to watch out for here.  Size of character set, and
  97.  * which character is the newline.  For this reason, and because
  98.  * I want to supply a copy of scan.c.dist which works for all
  99.  * systems, "make test" will produce output which you will have
  100.  * to interpret yourself.
  101.  */
  102. #if MPW
  103. /* Initial table for eight-bit chars, '\n' = 13. */
  104. static char e[256] =
  105.     {   0,
  106.         1,    1,    1,    1,    1,    1,    1,    1,    2,    1,
  107.         1,    1,    3,    1,    1,    1,    1,    1,    1,    1,
  108.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  109.         1,    2,    1,    4,    5,    6,    7,    1,    8,    9,
  110.         9,   10,    9,   11,   12,    9,   13,   14,   15,   15,
  111.        15,   15,   15,   15,   15,   15,   15,    1,    1,   16,
  112.         1,   17,    9,    1,   23,   22,   22,   22,   22,   22,
  113.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  114.        22,   24,   25,   26,   22,   22,   22,   27,   22,   22,
  115.        18,   19,   20,   21,   22,    1,   23,   22,   22,   22,
  116.  
  117.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  118.        22,   22,   22,   24,   25,   26,   22,   22,   22,   27,
  119.        22,   22,   28,   29,   30,    1,    1,    1,    1,    1,
  120.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  121.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  122.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  123.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  124.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  125.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  126.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  127.  
  128.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  129.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  130.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  131.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  132.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  133.         1,    1,    1,    1,    1
  134.     } ;
  135. #else
  136. /* Initial table for seven-bit chars, '\n' = 10. */
  137. static char e[128] =
  138.     {   0,
  139.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  140.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  141.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  142.         1,    2,    1,    4,    5,    6,    7,    1,    8,    9,
  143.         9,   10,    9,   11,   12,    9,   13,   14,   15,   15,
  144.        15,   15,   15,   15,   15,   15,   15,    1,    1,   16,
  145.         1,   17,    9,    1,   23,   22,   22,   22,   22,   22,
  146.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  147.        22,   24,   25,   26,   22,   22,   22,   27,   22,   22,
  148.        18,   19,   20,   21,   22,    1,   23,   22,   22,   22,
  149.  
  150.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  151.        22,   22,   22,   24,   25,   26,   22,   22,   22,   27,
  152.        22,   22,   28,   29,   30,    1,    1
  153.     } ;
  154. #endif
  155.  
  156. static char m[31] =
  157.     {   0,
  158.         1,    2,    3,    4,    1,    1,    1,    5,    1,    6,
  159.         1,    1,    5,    7,    7,    1,    1,    1,    8,    9,
  160.         1,    7,    7,    7,    7,    7,    7,    5,    1,   10
  161.     } ;
  162.  
  163. static short int b[276] =
  164.     {   0,
  165.         0,   26,   52,   80,  286,  285,    0,    0,  284,    1,
  166.         3,    7,   99,  116,  265,  264,  141,  169,   11,   13,
  167.         0,   22,   25,   47,  197,  225,  281,  280,    8,   10,
  168.        32,   54,   66,   69,   75,   85,   88,   99,  110,  112,
  169.       800,  280,  800,    0,   44,  800,  277,  104,  269,    0,
  170.       800,  144,  800,  800,   71,  800,  800,  259,   83,  242,
  171.       268,  800,  270,  266,  800,  271,    0,  800,  270,  800,
  172.        33,    0,  270,  800,  800,  800,  242,    0,  800,  800,
  173.       800,  800,   91,  800,  800,  800,  800,  114,  800,  800,
  174.       116,  250,  800,    0,  136,  800,    0,  800,  800,  126,
  175.  
  176.       251,  800,  800,  257,  800,  800,  800,  150,  800,  246,
  177.       151,  800,  245,    0,  800,  241,    0,  800,  800,    0,
  178.       249,  156,  800,  145,  249,    0,  247,  162,  800,  246,
  179.       800,  245,    0,  219,  800,  234,  800,    0,  167,  800,
  180.       206,  229,  800,  147,  165,  800,  162,    0,    0,  800,
  181.       284,  165,  313,  800,  178,  179,  184,    0,  800,  800,
  182.       218,    0,  800,    0,  178,  800,  180,    0,  800,  800,
  183.       800,    0,  190,  800,    0,  800,  216,  187,    0,  800,
  184.         0,  800,    0,  800,  185,  800,    0,  139,  146,  800,
  185.       800,  133,  800,  800,  188,  100,  197,    0,    0,  800,
  186.  
  187.       800,  210,  201,  213,  800,  212,    0,   97,  800,  203,
  188.        91,  800,   74,  800,    0,   51,  216,  209,  225,   34,
  189.       227,  800,  800,  800,  224,  800,  342,  352,  362,  372,
  190.       382,  392,  402,  412,  422,  432,  442,  452,  462,  472,
  191.       482,  492,  502,  512,   13,  522,  532,  542,   11,  552,
  192.       562,  572,  582,  592,  602,    0,  612,  622,  632,  642,
  193.       651,  661,  671,  681,  691,  701,  711,  721,  731,  740,
  194.       750,  760,  770,  780,  790
  195.     } ;
  196.  
  197. static short int d[276] =
  198.     {   0,
  199.       227,  227,  228,  228,  229,  229,  230,  230,  231,  231,
  200.       232,  232,  233,  233,  226,  226,  234,  234,  235,  235,
  201.       236,  236,  237,  237,  238,  238,  239,  239,  226,  226,
  202.       240,  240,  241,  241,  242,  242,  243,  243,  244,  244,
  203.       226,  226,  226,  245,  246,  226,  247,  248,  226,  249,
  204.       226,  226,  226,  226,  226,  226,  226,  250,  251,  252,
  205.       253,  226,  226,  226,  226,  229,  254,  226,  231,  226,
  206.       231,  255,  226,  226,  226,  226,  226,  256,  226,  226,
  207.       226,  226,  226,  226,  226,  226,  226,  251,  226,  226,
  208.       257,  258,  226,  259,  251,  226,  260,  226,  226,  261,
  209.  
  210.       226,  226,  226,  239,  226,  226,  226,  240,  226,  226,
  211.       241,  226,  226,  262,  226,  226,  263,  226,  226,  264,
  212.       244,  244,  226,  244,  226,  245,  246,  246,  226,  247,
  213.       226,  265,  266,  226,  226,  267,  226,  249,  226,  226,
  214.       226,  268,  226,  250,  250,  226,  226,  251,  269,  226,
  215.       269,  253,  253,  226,  253,  253,  270,  271,  226,  226,
  216.       272,  255,  226,  256,  226,  226,  226,  257,  226,  226,
  217.       226,  260,  261,  226,  261,  226,  273,  274,  262,  226,
  218.       263,  226,  275,  226,  265,  226,  266,  226,  267,  226,
  219.       226,  268,  226,  226,  250,  250,  226,  269,  151,  226,
  220.  
  221.       226,  253,  253,  270,  226,  270,  271,  272,  226,  226,
  222.       273,  226,  274,  226,  275,  226,  250,  226,  226,  226,
  223.       250,  226,  226,  226,  250,-32767,  226,  226,  226,  226,
  224.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  225.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  226.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  227.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  228.       226,  226,  226,  226,  226
  229.     } ;
  230.  
  231. static short int n[831] =
  232.     {   0,
  233.       226,   42,   43,   70,   73,   74,  164,   71,   73,   74,
  234.       106,   90,  106,   86,   87,   86,   87,  138,   91,  126,
  235.        92,   44,   44,   44,   44,   44,   44,   45,   46,   88,
  236.        47,   88,   48,   90,  109,   70,   94,  107,   49,  107,
  237.        91,  110,   92,   95,   96,  128,  129,   50,   50,   50,
  238.        50,   50,   50,   52,   53,   54,  109,   55,   94,  224,
  239.        56,   56,  161,  110,   56,   95,   96,   57,  112,   58,
  240.        59,  112,  143,  143,  220,  113,  214,  115,  113,   60,
  241.        56,   61,   62,   54,  116,   55,   63,  115,   56,   56,
  242.       118,  119,   64,  212,  116,   57,  147,   58,   59,  209,
  243.  
  244.        65,  118,  119,  148,  165,  165,  120,   60,   56,   76,
  245.       133,  122,  123,  122,  123,   77,  124,  120,  124,  144,
  246.        78,   78,   78,   78,   78,   78,   76,  147,  134,  167,
  247.       135,  136,   77,  174,  148,  193,  168,   78,   78,   78,
  248.        78,   78,   78,   81,  175,  139,  140,  226,  190,  147,
  249.       141,   82,  226,  226,   83,   83,  148,  122,  226,  226,
  250.       226,  216,  124,  128,  129,  145,  194,  201,  139,  140,
  251.        84,   81,  142,  141,  183,  197,  197,  202,  195,   82,
  252.       201,  201,   83,   83,  144,  196,  205,  186,  159,  214,
  253.       202,  165,  165,  210,  210,  142,  206,  174,   84,   98,
  254.  
  255.        99,  217,  217,  201,  100,  203,  145,  194,  175,  101,
  256.       218,  218,  201,  202,  205,  205,  219,  219,  212,  226,
  257.       209,  192,  222,  222,  102,  206,  103,   98,   99,  221,
  258.       221,  193,  100,  191,  145,  194,  190,  101,  223,  223,
  259.       225,  225,  145,  194,  188,  145,  194,  186,  131,  184,
  260.       125,  226,  102,  180,  103,  150,  150,  178,  177,  105,
  261.       176,  170,  163,  151,  151,  151,  151,  151,  151,  153,
  262.       154,   73,   70,   67,  155,  159,  158,  145,  137,  131,
  263.       156,  125,  105,  105,   79,   79,   70,   67,   67,  226,
  264.       226,  226,  226,  226,  226,  226,  157,  199,  199,  226,
  265.  
  266.       226,  226,  226,  226,  226,  199,  199,  199,  199,  199,
  267.       199,  226,  226,  200,  153,  154,  226,  226,  226,  155,
  268.       226,  226,  226,  226,  226,  156,  226,  226,  226,  226,
  269.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  270.       226,  157,   41,   41,   41,   41,   41,   41,   41,   41,
  271.        41,   41,   51,   51,   51,   51,   51,   51,   51,   51,
  272.        51,   51,   66,   66,   66,   66,   66,   66,   66,   66,
  273.        66,   66,   68,   68,   68,   68,   68,   68,   68,   68,
  274.        68,   68,   69,   69,   69,   69,   69,   69,   69,   69,
  275.        69,   69,   72,   72,   72,   72,   72,   72,   72,   72,
  276.  
  277.        72,   72,   75,   75,  226,   75,   75,   75,   75,   75,
  278.        75,   75,   80,   80,   80,   80,   80,   80,   80,   80,
  279.        80,   80,   85,   85,   85,   85,   85,   85,   85,   85,
  280.        85,   85,   89,   89,  226,   89,   89,   89,   89,   89,
  281.        89,   89,   93,   93,  226,   93,   93,   93,   93,   93,
  282.        93,   93,   97,   97,   97,   97,   97,   97,   97,   97,
  283.        97,   97,  104,  104,  104,  104,  104,  104,  104,  104,
  284.       104,  104,  108,  108,  108,  108,  108,  108,  108,  108,
  285.       108,  108,  111,  111,  111,  111,  111,  111,  111,  111,
  286.       111,  111,  114,  114,  114,  114,  114,  114,  114,  114,
  287.  
  288.       114,  114,  117,  117,  117,  117,  117,  117,  117,  117,
  289.       117,  117,  121,  121,  121,  121,  121,  121,  121,  121,
  290.       121,  121,  127,  127,  127,  127,  127,  127,  127,  127,
  291.       127,  127,  130,  130,  130,  130,  130,  130,  130,  130,
  292.       130,  130,  132,  132,  132,  132,  132,  132,  132,  132,
  293.       132,  132,  144,  144,  226,  144,  144,  144,  144,  144,
  294.       226,  144,  146,  146,  226,  146,  146,  146,  146,  146,
  295.       146,  146,  149,  149,  226,  149,  149,  149,  149,  149,
  296.       149,  149,  152,  152,  152,  152,  152,  152,  152,  152,
  297.       152,  152,  160,  226,  226,  160,  160,  160,  160,  160,
  298.  
  299.       160,  160,  162,  162,  226,  162,  162,  162,  162,  162,
  300.       162,  162,  166,  166,  226,  166,  166,  166,  166,  166,
  301.       166,  166,  169,  169,  226,  169,  169,  169,  169,  169,
  302.       169,  169,  171,  171,  226,  171,  171,  171,  171,  171,
  303.       226,  171,  172,  172,  226,  226,  226,  172,  172,  172,
  304.       172,  173,  173,  226,  173,  173,  173,  173,  173,  173,
  305.       173,  179,  179,  226,  179,  179,  226,  179,  179,  179,
  306.       179,  181,  181,  226,  226,  181,  181,  181,  226,  181,
  307.       181,  182,  182,  226,  182,  182,  182,  182,  182,  182,
  308.       182,  185,  185,  185,  185,  185,  185,  185,  185,  185,
  309.  
  310.       185,  187,  187,  226,  187,  187,  187,  187,  187,  187,
  311.       187,  189,  189,  189,  189,  189,  189,  189,  189,  189,
  312.       189,  192,  192,  192,  192,  192,  192,  192,  192,  192,
  313.       192,  198,  198,  226,  198,  198,  198,  198,  198,  198,
  314.       204,  204,  204,  204,  204,  204,  204,  204,  204,  204,
  315.       207,  207,  226,  207,  207,  207,  207,  207,  207,  207,
  316.       208,  208,  208,  208,  208,  208,  208,  208,  208,  208,
  317.       211,  211,  211,  211,  211,  211,  211,  211,  211,  211,
  318.       213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
  319.       215,  215,  226,  215,  215,  215,  215,  215,  215,  215,
  320.  
  321.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  322.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  323.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226
  324.     } ;
  325.  
  326. static short int c[831] =
  327.     {   0,
  328.         0,    1,    1,   10,   11,   11,  256,   10,   12,   12,
  329.        29,   21,   30,   19,   19,   20,   20,  249,   21,  245,
  330.        21,    1,    1,    1,    1,    1,    1,    2,    2,   19,
  331.         2,   20,    2,   22,   31,   71,   23,   29,    2,   30,
  332.        22,   31,   22,   23,   23,   45,   45,    2,    2,    2,
  333.         2,    2,    2,    3,    3,    3,   32,    3,   24,  220,
  334.         3,    3,   71,   32,    3,   24,   24,    3,   33,    3,
  335.         3,   34,   55,   55,  216,   33,  213,   35,   34,    3,
  336.         3,    4,    4,    4,   35,    4,    4,   36,    4,    4,
  337.        37,   37,    4,  211,   36,    4,   59,    4,    4,  208,
  338.  
  339.         4,   38,   38,   59,   83,   83,   37,    4,    4,   13,
  340.        48,   39,   39,   40,   40,   13,   39,   38,   40,  196,
  341.        13,   13,   13,   13,   13,   13,   14,   88,   48,   91,
  342.        48,   48,   14,  100,   88,  192,   91,   14,   14,   14,
  343.        14,   14,   14,   17,  100,   52,   52,  124,  189,   95,
  344.        52,   17,  108,  111,   17,   17,   95,  122,  122,  108,
  345.       111,  188,  122,  128,  128,  144,  144,  152,  139,  139,
  346.        17,   18,   52,  139,  124,  147,  147,  152,  145,   18,
  347.       155,  156,   18,   18,  145,  145,  157,  185,  156,  178,
  348.       155,  165,  165,  167,  167,  139,  157,  173,   18,   25,
  349.  
  350.        25,  195,  195,  203,   25,  155,  195,  195,  173,   25,
  351.       197,  197,  202,  203,  206,  204,  210,  210,  177,  202,
  352.       161,  206,  218,  218,   25,  204,   25,   26,   26,  217,
  353.       217,  142,   26,  141,  217,  217,  136,   26,  219,  219,
  354.       221,  221,  225,  225,  134,  221,  221,  132,  130,  127,
  355.       125,  121,   26,  116,   26,   60,   60,  113,  110,  104,
  356.       101,   92,   77,   60,   60,   60,   60,   60,   60,   61,
  357.        61,   73,   69,   66,   61,   64,   63,   58,   49,   47,
  358.        61,   42,   28,   27,   16,   15,    9,    6,    5,    0,
  359.         0,    0,    0,    0,    0,    0,   61,  151,  151,    0,
  360.  
  361.         0,    0,    0,    0,    0,  151,  151,  151,  151,  151,
  362.       151,    0,    0,  151,  153,  153,    0,    0,    0,  153,
  363.         0,    0,    0,    0,    0,  153,    0,    0,    0,    0,
  364.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  365.         0,  153,  227,  227,  227,  227,  227,  227,  227,  227,
  366.       227,  227,  228,  228,  228,  228,  228,  228,  228,  228,
  367.       228,  228,  229,  229,  229,  229,  229,  229,  229,  229,
  368.       229,  229,  230,  230,  230,  230,  230,  230,  230,  230,
  369.       230,  230,  231,  231,  231,  231,  231,  231,  231,  231,
  370.       231,  231,  232,  232,  232,  232,  232,  232,  232,  232,
  371.  
  372.       232,  232,  233,  233,    0,  233,  233,  233,  233,  233,
  373.       233,  233,  234,  234,  234,  234,  234,  234,  234,  234,
  374.       234,  234,  235,  235,  235,  235,  235,  235,  235,  235,
  375.       235,  235,  236,  236,    0,  236,  236,  236,  236,  236,
  376.       236,  236,  237,  237,    0,  237,  237,  237,  237,  237,
  377.       237,  237,  238,  238,  238,  238,  238,  238,  238,  238,
  378.       238,  238,  239,  239,  239,  239,  239,  239,  239,  239,
  379.       239,  239,  240,  240,  240,  240,  240,  240,  240,  240,
  380.       240,  240,  241,  241,  241,  241,  241,  241,  241,  241,
  381.       241,  241,  242,  242,  242,  242,  242,  242,  242,  242,
  382.  
  383.       242,  242,  243,  243,  243,  243,  243,  243,  243,  243,
  384.       243,  243,  244,  244,  244,  244,  244,  244,  244,  244,
  385.       244,  244,  246,  246,  246,  246,  246,  246,  246,  246,
  386.       246,  246,  247,  247,  247,  247,  247,  247,  247,  247,
  387.       247,  247,  248,  248,  248,  248,  248,  248,  248,  248,
  388.       248,  248,  250,  250,    0,  250,  250,  250,  250,  250,
  389.         0,  250,  251,  251,    0,  251,  251,  251,  251,  251,
  390.       251,  251,  252,  252,    0,  252,  252,  252,  252,  252,
  391.       252,  252,  253,  253,  253,  253,  253,  253,  253,  253,
  392.       253,  253,  254,    0,    0,  254,  254,  254,  254,  254,
  393.  
  394.       254,  254,  255,  255,    0,  255,  255,  255,  255,  255,
  395.       255,  255,  257,  257,    0,  257,  257,  257,  257,  257,
  396.       257,  257,  258,  258,    0,  258,  258,  258,  258,  258,
  397.       258,  258,  259,  259,    0,  259,  259,  259,  259,  259,
  398.         0,  259,  260,  260,    0,    0,    0,  260,  260,  260,
  399.       260,  261,  261,    0,  261,  261,  261,  261,  261,  261,
  400.       261,  262,  262,    0,  262,  262,    0,  262,  262,  262,
  401.       262,  263,  263,    0,    0,  263,  263,  263,    0,  263,
  402.       263,  264,  264,    0,  264,  264,  264,  264,  264,  264,
  403.       264,  265,  265,  265,  265,  265,  265,  265,  265,  265,
  404.  
  405.       265,  266,  266,    0,  266,  266,  266,  266,  266,  266,
  406.       266,  267,  267,  267,  267,  267,  267,  267,  267,  267,
  407.       267,  268,  268,  268,  268,  268,  268,  268,  268,  268,
  408.       268,  269,  269,    0,  269,  269,  269,  269,  269,  269,
  409.       270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
  410.       271,  271,    0,  271,  271,  271,  271,  271,  271,  271,
  411.       272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
  412.       273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  413.       274,  274,  274,  274,  274,  274,  274,  274,  274,  274,
  414.       275,  275,    0,  275,  275,  275,  275,  275,  275,  275,
  415.  
  416.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  417.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  418.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226
  419.     } ;
  420.  
  421.  
  422. /* these declarations have to come after the section 1 code or lint gets
  423.  * confused about whether the variables are used
  424.  */
  425. FILE *yyin = stdin, *yyout = stdout;
  426.  
  427. /* these variables are all declared out here so that section 3 code can
  428.  * manipulate them
  429.  */
  430. static int yy_start, yy_b_buf_p, yy_c_buf_p, yy_e_buf_p;
  431. static int yy_saw_eof, yy_init = 1;
  432.  
  433. /* yy_ch_buf has to be 1 character longer than YY_BUF_SIZE, since when
  434.  * setting up yytext we can try to put a '\0' just past the end of the
  435.  * matched text
  436.  */
  437. #ifdef MALLOC_BUFFERS
  438. static char *yy_ch_buf = 0L;
  439. static int *yy_st_buf = 0L;
  440. #else
  441. static char yy_ch_buf[YY_BUF_SIZE + 1];
  442. static int yy_st_buf[YY_BUF_SIZE];
  443. #endif
  444. static char yy_hold_char;
  445. char *yytext;
  446. static int yyleng;
  447.  
  448. YY_DECL
  449.     {
  450.     int yy_n_chars, yy_lp, yy_iii, yy_buf_pos, yy_act;
  451.  
  452.  
  453.     static int bracelevel, didadef;
  454.     int i, cclval;
  455.     char nmdef[MAXLINE], myesc();
  456.  
  457.  
  458. #ifdef MALLOC_BUFFERS
  459.     if(yy_ch_buf == 0L){
  460.         yy_ch_buf = (char *)malloc(YY_BUF_SIZE + 1);
  461.         yy_st_buf = (int *)malloc(YY_BUF_SIZE * sizeof(int));
  462.         if(yy_ch_buf == 0L || yy_st_buf == 0L){
  463.             fprintf( stderr, "Out of memory\n");
  464.             exit(-1);
  465.         }
  466.     }
  467. #endif
  468.     if ( yy_init )
  469.     {
  470.     YY_INIT;
  471.     yy_start = 1;
  472.     yy_init = 0;
  473.     }
  474.  
  475.     goto get_next_token;
  476.  
  477. do_action:
  478.     for ( ; ; )
  479.     {
  480.     YY_DO_BEFORE_ACTION
  481.  
  482. #ifdef FLEX_DEBUG
  483.     fprintf( stderr, "--accepting rule #%d\n", yy_act );
  484. #endif
  485.     switch ( yy_act )
  486.         {
  487. case 1:
  488. # line 58 "scan.l"
  489. ++linenum; ECHO; /* indented code */
  490.     YY_BREAK
  491. case 2:
  492. # line 59 "scan.l"
  493. ++linenum; ECHO; /* treat as a comment */
  494.     YY_BREAK
  495. case 3:
  496. # line 60 "scan.l"
  497. ECHO; BEGIN(C_COMMENT);
  498.     YY_BREAK
  499. case 4:
  500. # line 61 "scan.l"
  501. return ( SCDECL );
  502.     YY_BREAK
  503. case 5:
  504. # line 62 "scan.l"
  505. return ( XSCDECL );
  506.     YY_BREAK
  507. case 6:
  508. # line 63 "scan.l"
  509. ++linenum; line_directive_out( stdout ); BEGIN(CODEBLOCK);
  510.     YY_BREAK
  511. case 7:
  512. # line 64 "scan.l"
  513. return ( WHITESPACE );
  514.     YY_BREAK
  515. case 8:
  516. # line 66 "scan.l"
  517. {
  518.             sectnum = 2;
  519.             line_directive_out( stdout );
  520.             BEGIN(SECT2PROLOG);
  521.             return ( SECTEND );
  522.             }
  523.     YY_BREAK
  524. case 9:
  525. # line 73 "scan.l"
  526. {
  527.             fprintf( stderr,
  528.                  "old-style lex command at line %d ignored:\n\t%s",
  529.                  linenum, yytext );
  530.             ++linenum;
  531.             }
  532.     YY_BREAK
  533. case 10:
  534. # line 80 "scan.l"
  535. {
  536.             (void) strcpy( nmstr, yytext );
  537.             didadef = false;
  538.             BEGIN(PICKUPDEF);
  539.             }
  540.     YY_BREAK
  541. case 11:
  542. # line 86 "scan.l"
  543. RETURNNAME;
  544.     YY_BREAK
  545. case 12:
  546. # line 87 "scan.l"
  547. ++linenum; /* allows blank lines in section 1 */
  548.     YY_BREAK
  549. case 13:
  550. # line 88 "scan.l"
  551. ++linenum; return ( '\n' );
  552.     YY_BREAK
  553. case 14:
  554. # line 89 "scan.l"
  555. synerr( "illegal character" ); BEGIN(RECOVER);
  556.     YY_BREAK
  557. case 15:
  558. # line 92 "scan.l"
  559. ECHO; BEGIN(0);
  560.     YY_BREAK
  561. case 16:
  562. # line 93 "scan.l"
  563. ++linenum; ECHO; BEGIN(0);
  564.     YY_BREAK
  565. case 17:
  566. # line 94 "scan.l"
  567. ECHO;
  568.     YY_BREAK
  569. case 18:
  570. # line 95 "scan.l"
  571. ECHO;
  572.     YY_BREAK
  573. case 19:
  574. # line 96 "scan.l"
  575. ++linenum; ECHO;
  576.     YY_BREAK
  577. case 20:
  578. # line 98 "scan.l"
  579. ++linenum; BEGIN(0);
  580.     YY_BREAK
  581. case 21:
  582. # line 99 "scan.l"
  583. ++linenum; ECHO;
  584.     YY_BREAK
  585. case 22:
  586. # line 101 "scan.l"
  587. /* separates name and definition */
  588.     YY_BREAK
  589. case 23:
  590. # line 103 "scan.l"
  591. {
  592.             (void) strcpy( nmdef, yytext );
  593.  
  594.             for ( i = strlen( nmdef ) - 1;
  595.                   i >= 0 &&
  596.                   nmdef[i] == ' ' || nmdef[i] == '\t';
  597.                   --i )
  598.                 ;
  599.  
  600.             nmdef[i + 1] = '\0';
  601.  
  602.                         ndinstal( nmstr, nmdef );
  603.             didadef = true;
  604.             }
  605.     YY_BREAK
  606. case 24:
  607. # line 118 "scan.l"
  608. {
  609.             if ( ! didadef )
  610.                 synerr( "incomplete name definition" );
  611.             BEGIN(0);
  612.             ++linenum;
  613.             }
  614.     YY_BREAK
  615. case 25:
  616. # line 125 "scan.l"
  617. ++linenum; BEGIN(0); RETURNNAME;
  618.     YY_BREAK
  619. case 26:
  620. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  621. yy_c_buf_p -= 1;
  622. YY_DO_BEFORE_ACTION; /* set up yytext again */
  623. # line 128 "scan.l"
  624. {
  625.             ++linenum;
  626.             ACTION_ECHO;
  627.             MARK_END_OF_PROLOG;
  628.             BEGIN(SECT2);
  629.             }
  630.     YY_BREAK
  631. case 27:
  632. # line 135 "scan.l"
  633. ++linenum; ACTION_ECHO;
  634.     YY_BREAK
  635. case 28:
  636. # line 137 "scan.l"
  637. ++linenum; /* allow blank lines in section 2 */
  638.     YY_BREAK
  639.     /* this horrible mess of a rule matches indented lines which
  640.      * do not contain "/*".  We need to make the distinction because
  641.      * otherwise this rule will be taken instead of the rule which
  642.      * matches the beginning of comments like this one
  643.      */
  644. case 29:
  645. # line 144 "scan.l"
  646. {
  647.             synerr( "indented code found outside of action" );
  648.             ++linenum;
  649.             }
  650.     YY_BREAK
  651. case 30:
  652. # line 149 "scan.l"
  653. BEGIN(SC); return ( '<' );
  654.     YY_BREAK
  655. case 31:
  656. # line 150 "scan.l"
  657. return ( '^' );
  658.     YY_BREAK
  659. case 32:
  660. # line 151 "scan.l"
  661. BEGIN(QUOTE); return ( '"' );
  662.     YY_BREAK
  663. case 33:
  664. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  665. yy_c_buf_p = yy_b_buf_p;
  666. YY_DO_BEFORE_ACTION; /* set up yytext again */
  667. # line 152 "scan.l"
  668. BEGIN(NUM); return ( '{' );
  669.     YY_BREAK
  670. case 34:
  671. # line 153 "scan.l"
  672. BEGIN(BRACEERROR);
  673.     YY_BREAK
  674. case 35:
  675. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  676. yy_c_buf_p = yy_b_buf_p;
  677. YY_DO_BEFORE_ACTION; /* set up yytext again */
  678. # line 154 "scan.l"
  679. return ( '$' );
  680.     YY_BREAK
  681. case 36:
  682. # line 156 "scan.l"
  683. {
  684.             bracelevel = 1;
  685.             BEGIN(PERCENT_BRACE_ACTION);
  686.             return ( '\n' );
  687.             }
  688.     YY_BREAK
  689. case 37:
  690. # line 161 "scan.l"
  691. ++linenum; return ( '\n' );
  692.     YY_BREAK
  693. case 38:
  694. # line 163 "scan.l"
  695. ACTION_ECHO; BEGIN(C_COMMENT_2);
  696.     YY_BREAK
  697. case 39:
  698. # line 165 "scan.l"
  699. { /* needs to be separate from following rule due to
  700.                * bug with trailing context
  701.                */
  702.             bracelevel = 0;
  703.             BEGIN(ACTION);
  704.             return ( '\n' );
  705.             }
  706.     YY_BREAK
  707. case 40:
  708. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  709. yy_c_buf_p -= 1;
  710. YY_DO_BEFORE_ACTION; /* set up yytext again */
  711. # line 173 "scan.l"
  712. {
  713.             bracelevel = 0;
  714.             BEGIN(ACTION);
  715.             return ( '\n' );
  716.             }
  717.     YY_BREAK
  718. case 41:
  719. # line 179 "scan.l"
  720. ++linenum; return ( '\n' );
  721.     YY_BREAK
  722. case 42:
  723. # line 181 "scan.l"
  724. {
  725.             /* guarantee that the SECT3 rule will have something
  726.              * to match
  727.              */
  728.             yyless(1);
  729.             sectnum = 3;
  730.             BEGIN(SECT3);
  731.             return ( EOF ); /* to stop the parser */
  732.             }
  733.     YY_BREAK
  734. case 43:
  735. # line 191 "scan.l"
  736. {
  737.             (void) strcpy( nmstr, yytext );
  738.  
  739.             /* check to see if we've already encountered this ccl */
  740.             if ( (cclval = ccllookup( nmstr )) )
  741.                 {
  742.                 yylval = cclval;
  743.                 ++cclreuse;
  744.                 return ( PREVCCL );
  745.                 }
  746.             else
  747.                 {
  748.                 /* we fudge a bit.  We know that this ccl will
  749.                  * soon be numbered as lastccl + 1 by cclinit
  750.                  */
  751.                 cclinstal( nmstr, lastccl + 1 );
  752.  
  753.                 /* push back everything but the leading bracket
  754.                  * so the ccl can be rescanned
  755.                  */
  756.                 PUT_BACK_STRING(nmstr, 1);
  757.  
  758.                 BEGIN(FIRSTCCL);
  759.                 return ( '[' );
  760.                 }
  761.             }
  762.     YY_BREAK
  763. case 44:
  764. # line 218 "scan.l"
  765. {
  766.             register char *nmdefptr;
  767.             char *ndlookup();
  768.  
  769.             (void) strcpy( nmstr, yytext );
  770.             nmstr[yyleng - 1] = '\0';  /* chop trailing brace */
  771.  
  772.             /* lookup from "nmstr + 1" to chop leading brace */
  773.             if ( ! (nmdefptr = ndlookup( nmstr + 1 )) )
  774.                 synerr( "undefined {name}" );
  775.  
  776.             else
  777.                 { /* push back name surrounded by ()'s */
  778.                 unput(')');
  779.                 PUT_BACK_STRING(nmdefptr, 0);
  780.                 unput('(');
  781.                 }
  782.             }
  783.     YY_BREAK
  784. case 45:
  785. # line 237 "scan.l"
  786. return ( yytext[0] );
  787.     YY_BREAK
  788. case 46:
  789. # line 238 "scan.l"
  790. RETURNCHAR;
  791.     YY_BREAK
  792. case 47:
  793. # line 239 "scan.l"
  794. ++linenum; return ( '\n' );
  795.     YY_BREAK
  796. case 48:
  797. # line 242 "scan.l"
  798. return ( ',' );
  799.     YY_BREAK
  800. case 49:
  801. # line 243 "scan.l"
  802. BEGIN(SECT2); return ( '>' );
  803.     YY_BREAK
  804. case 50:
  805. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  806. yy_c_buf_p = yy_b_buf_p;
  807. YY_DO_BEFORE_ACTION; /* set up yytext again */
  808. # line 244 "scan.l"
  809. BEGIN(CARETISBOL); return ( '>' );
  810.     YY_BREAK
  811. case 51:
  812. # line 245 "scan.l"
  813. RETURNNAME;
  814.     YY_BREAK
  815. case 52:
  816. # line 246 "scan.l"
  817. synerr( "bad start condition name" );
  818.     YY_BREAK
  819. case 53:
  820. # line 248 "scan.l"
  821. BEGIN(SECT2); return ( '^' );
  822.     YY_BREAK
  823. case 54:
  824. # line 251 "scan.l"
  825. RETURNCHAR;
  826.     YY_BREAK
  827. case 55:
  828. # line 252 "scan.l"
  829. BEGIN(SECT2); return ( '"' );
  830.     YY_BREAK
  831. case 56:
  832. # line 254 "scan.l"
  833. {
  834.             synerr( "missing quote" );
  835.             BEGIN(SECT2);
  836.             ++linenum;
  837.             return ( '"' );
  838.             }
  839.     YY_BREAK
  840. case 57:
  841. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  842. yy_c_buf_p = yy_b_buf_p;
  843. YY_DO_BEFORE_ACTION; /* set up yytext again */
  844. # line 262 "scan.l"
  845. BEGIN(CCL); return ( '^' );
  846.     YY_BREAK
  847. case 58:
  848. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  849. yy_c_buf_p = yy_b_buf_p;
  850. YY_DO_BEFORE_ACTION; /* set up yytext again */
  851. # line 263 "scan.l"
  852. return ( '^' );
  853.     YY_BREAK
  854. case 59:
  855. # line 264 "scan.l"
  856. BEGIN(CCL); yylval = '-'; return ( CHAR );
  857.     YY_BREAK
  858. case 60:
  859. # line 265 "scan.l"
  860. BEGIN(CCL); RETURNCHAR;
  861.     YY_BREAK
  862. case 61:
  863. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  864. yy_c_buf_p = yy_b_buf_p;
  865. YY_DO_BEFORE_ACTION; /* set up yytext again */
  866. # line 267 "scan.l"
  867. return ( '-' );
  868.     YY_BREAK
  869. case 62:
  870. # line 268 "scan.l"
  871. RETURNCHAR;
  872.     YY_BREAK
  873. case 63:
  874. # line 269 "scan.l"
  875. BEGIN(SECT2); return ( ']' );
  876.     YY_BREAK
  877. case 64:
  878. # line 272 "scan.l"
  879. {
  880.             yylval = myctoi( yytext );
  881.             return ( NUMBER );
  882.             }
  883.     YY_BREAK
  884. case 65:
  885. # line 277 "scan.l"
  886. return ( ',' );
  887.     YY_BREAK
  888. case 66:
  889. # line 278 "scan.l"
  890. BEGIN(SECT2); return ( '}' );
  891.     YY_BREAK
  892. case 67:
  893. # line 280 "scan.l"
  894. {
  895.             synerr( "bad character inside {}'s" );
  896.             BEGIN(SECT2);
  897.             return ( '}' );
  898.             }
  899.     YY_BREAK
  900. case 68:
  901. # line 286 "scan.l"
  902. {
  903.             synerr( "missing }" );
  904.             BEGIN(SECT2);
  905.             ++linenum;
  906.             return ( '}' );
  907.             }
  908.     YY_BREAK
  909. case 69:
  910. # line 294 "scan.l"
  911. synerr( "bad name in {}'s" ); BEGIN(SECT2);
  912.     YY_BREAK
  913. case 70:
  914. # line 295 "scan.l"
  915. synerr( "missing }" ); ++linenum; BEGIN(SECT2);
  916.     YY_BREAK
  917. case 71:
  918. # line 298 "scan.l"
  919. bracelevel = 0;
  920.     YY_BREAK
  921. case 72:
  922. # line 299 "scan.l"
  923. ACTION_ECHO;
  924.     YY_BREAK
  925. case 73:
  926. # line 300 "scan.l"
  927. {
  928.             ++linenum;
  929.             ACTION_ECHO;
  930.             if ( bracelevel == 0 )
  931.                 {
  932.                 fputs( "\tYY_BREAK\n", temp_action_file );
  933.                 BEGIN(SECT2);
  934.                 }
  935.             }
  936.     YY_BREAK
  937. case 74:
  938. # line 310 "scan.l"
  939. ACTION_ECHO; ++bracelevel;
  940.     YY_BREAK
  941. case 75:
  942. # line 311 "scan.l"
  943. ACTION_ECHO; --bracelevel;
  944.     YY_BREAK
  945. case 76:
  946. # line 312 "scan.l"
  947. ACTION_ECHO;
  948.     YY_BREAK
  949. case 77:
  950. # line 313 "scan.l"
  951. ACTION_ECHO; BEGIN(ACTION_COMMENT);
  952.     YY_BREAK
  953. case 78:
  954. # line 314 "scan.l"
  955. ACTION_ECHO; /* character constant */
  956.     YY_BREAK
  957. case 79:
  958. # line 315 "scan.l"
  959. ACTION_ECHO; BEGIN(ACTION_STRING);
  960.     YY_BREAK
  961. case 80:
  962. # line 316 "scan.l"
  963. {
  964.             ++linenum;
  965.             ACTION_ECHO;
  966.             if ( bracelevel == 0 )
  967.                 {
  968.                 fputs( "\tYY_BREAK\n", temp_action_file );
  969.                 BEGIN(SECT2);
  970.                 }
  971.             }
  972.     YY_BREAK
  973. case 81:
  974. # line 325 "scan.l"
  975. ACTION_ECHO;
  976.     YY_BREAK
  977. case 82:
  978. # line 327 "scan.l"
  979. ACTION_ECHO; BEGIN(ACTION);
  980.     YY_BREAK
  981. case 83:
  982. # line 328 "scan.l"
  983. ACTION_ECHO;
  984.     YY_BREAK
  985. case 84:
  986. # line 329 "scan.l"
  987. ACTION_ECHO;
  988.     YY_BREAK
  989. case 85:
  990. # line 330 "scan.l"
  991. ++linenum; ACTION_ECHO;
  992.     YY_BREAK
  993. case 86:
  994. # line 331 "scan.l"
  995. ACTION_ECHO;
  996.     YY_BREAK
  997. case 87:
  998. # line 333 "scan.l"
  999. ACTION_ECHO; BEGIN(SECT2);
  1000.     YY_BREAK
  1001. case 88:
  1002. # line 334 "scan.l"
  1003. ++linenum; ACTION_ECHO; BEGIN(SECT2);
  1004.     YY_BREAK
  1005. case 89:
  1006. # line 335 "scan.l"
  1007. ACTION_ECHO;
  1008.     YY_BREAK
  1009. case 90:
  1010. # line 336 "scan.l"
  1011. ACTION_ECHO;
  1012.     YY_BREAK
  1013. case 91:
  1014. # line 337 "scan.l"
  1015. ++linenum; ACTION_ECHO;
  1016.     YY_BREAK
  1017. case 92:
  1018. # line 339 "scan.l"
  1019. ACTION_ECHO;
  1020.     YY_BREAK
  1021. case 93:
  1022. # line 340 "scan.l"
  1023. ACTION_ECHO;
  1024.     YY_BREAK
  1025. case 94:
  1026. # line 341 "scan.l"
  1027. ++linenum; ACTION_ECHO;
  1028.     YY_BREAK
  1029. case 95:
  1030. # line 342 "scan.l"
  1031. ACTION_ECHO; BEGIN(ACTION);
  1032.     YY_BREAK
  1033. case 96:
  1034. # line 343 "scan.l"
  1035. ACTION_ECHO;
  1036.     YY_BREAK
  1037. case 97:
  1038. # line 346 "scan.l"
  1039. {
  1040.             yylval = myesc( yytext ) & BYTEMASK;
  1041.             return ( CHAR );
  1042.             }
  1043.     YY_BREAK
  1044. case 98:
  1045. # line 351 "scan.l"
  1046. {
  1047.             yylval = myesc( yytext ) & BYTEMASK;
  1048.             BEGIN(CCL);
  1049.             return ( CHAR );
  1050.             }
  1051.     YY_BREAK
  1052. case 99:
  1053. # line 358 "scan.l"
  1054. {
  1055.             register int numchars;
  1056.  
  1057.             /* black magic - we know the names of a flex scanner's
  1058.              * internal variables.  We cap the input buffer with
  1059.              * an end-of-string and dump it to the output.
  1060.              */
  1061.             YY_DO_BEFORE_SCAN; /* recover from setting up yytext */
  1062.  
  1063. #ifdef FLEX_FAST_SKEL
  1064.             fputs( yy_c_buf_p + 1, stdout );
  1065. #else
  1066.             yy_ch_buf[yy_e_buf_p + 1] = '\0';
  1067.  
  1068.             /* ignore the first character; it's the second '%'
  1069.              * put back by the yyless(1) above
  1070.              */
  1071.             fputs( yy_ch_buf + yy_c_buf_p + 1, stdout );
  1072. #endif
  1073.  
  1074.             /* if we don't do this, the data written by write()
  1075.              * can get overwritten when stdout is finally flushed
  1076.              */
  1077.             (void) fflush( stdout );
  1078.  
  1079.             while ( (numchars = read( fileno(yyin), yy_ch_buf,
  1080.                           YY_BUF_MAX )) > 0 )
  1081.                 (void) write( fileno(stdout), yy_ch_buf, numchars );
  1082.     
  1083.             if ( numchars < 0 )
  1084.                 flexerror( "fatal read error in section 3" );
  1085.  
  1086.             return ( EOF );
  1087.             }
  1088.     YY_BREAK
  1089.  
  1090. case YY_NEW_FILE:
  1091. break; /* begin reading from new file */
  1092.  
  1093. case YY_DO_DEFAULT:
  1094. YY_DEFAULT_ACTION;
  1095. break;
  1096.  
  1097. case YY_END_TOK:
  1098. return ( YY_END_TOK );
  1099.  
  1100. default:
  1101. YY_FATAL_ERROR( "fatal flex scanner internal error" );
  1102.         }
  1103.  
  1104. get_next_token:
  1105.     {
  1106.     register int yy_curst;
  1107.     register char yy_sym;
  1108.  
  1109.     YY_DO_BEFORE_SCAN
  1110.  
  1111.     /* set up to begin running DFA */
  1112.  
  1113.     yy_curst = yy_start;
  1114.  
  1115.     if ( yy_ch_buf[yy_c_buf_p] == '\n' )
  1116.         ++yy_curst;
  1117.  
  1118.     /* yy_b_buf_p points to the position in yy_ch_buf
  1119.      * of the start of the current run.
  1120.      */
  1121.  
  1122.     yy_b_buf_p = yy_c_buf_p + 1;
  1123.  
  1124.     do /* until the machine jams */
  1125.         {
  1126.         if ( yy_c_buf_p == yy_e_buf_p )
  1127.         { /* need more input */
  1128.         if ( yy_e_buf_p >= YY_BUF_LIM )
  1129.             { /* not enough room to do another read */
  1130.             /* see if we can make some room for more chars */
  1131.  
  1132.             yy_n_chars = yy_e_buf_p - yy_b_buf_p;
  1133.  
  1134.             if ( yy_n_chars >= 0 )
  1135.             /* shift down buffer to make room */
  1136.             for ( yy_iii = 0; yy_iii <= yy_n_chars; ++yy_iii )
  1137.                 {
  1138.                 yy_buf_pos = yy_b_buf_p + yy_iii;
  1139.                 yy_ch_buf[yy_iii] = yy_ch_buf[yy_buf_pos];
  1140.                 yy_st_buf[yy_iii] = yy_st_buf[yy_buf_pos];
  1141.                 }
  1142.  
  1143.             yy_b_buf_p = 0;
  1144.             yy_e_buf_p = yy_n_chars;
  1145.  
  1146.             if ( yy_e_buf_p >= YY_BUF_LIM )
  1147.             YY_FATAL_ERROR( "flex input buffer overflowed" );
  1148.  
  1149.             yy_c_buf_p = yy_e_buf_p;
  1150.             }
  1151.  
  1152.         else if ( yy_saw_eof )
  1153.             {
  1154. saweof:            if ( yy_b_buf_p > yy_e_buf_p )
  1155.             {
  1156.             if ( yywrap() )
  1157.                 {
  1158.                 yy_act = YY_END_TOK;
  1159.                 goto do_action;
  1160.                 }
  1161.             
  1162.             else
  1163.                 {
  1164.                 YY_INIT;
  1165.                 yy_act = YY_NEW_FILE;
  1166.                 goto do_action;
  1167.                 }
  1168.             }
  1169.  
  1170.             else /* do a jam to eat up more input */
  1171.             {
  1172. #ifndef FLEX_INTERACTIVE_SCANNER
  1173.             /* we're going to decrement yy_c_buf_p upon doing
  1174.              * the jam.  In this case, that's wrong, since
  1175.              * it points to the last non-jam character.  So
  1176.              * we increment it now to counter the decrement.
  1177.              */
  1178.             ++yy_c_buf_p;
  1179. #endif
  1180.             break;
  1181.             }
  1182.             }
  1183.  
  1184.         YY_INPUT( (yy_ch_buf + yy_c_buf_p + 1), yy_n_chars,
  1185.               YY_MAX_LINE );
  1186.  
  1187.         if ( yy_n_chars == YY_NULL )
  1188.             {
  1189.             if ( yy_saw_eof )
  1190.     YY_FATAL_ERROR( "flex scanner saw EOF twice - shouldn't happen" );
  1191.             yy_saw_eof = 1;
  1192.             goto saweof;
  1193.             }
  1194.  
  1195.         yy_e_buf_p += yy_n_chars;
  1196.         }
  1197.  
  1198.         ++yy_c_buf_p;
  1199.  
  1200. #ifdef FLEX_USE_ECS
  1201.         yy_sym = e[(yy_ch_buf[yy_c_buf_p] & BYTEMASK)];
  1202. #else
  1203.         yy_sym = yy_ch_buf[yy_c_buf_p];
  1204. #endif
  1205.  
  1206. #ifdef FLEX_FULL_TABLE
  1207.         yy_curst = n[yy_curst][yy_sym];
  1208.  
  1209. #else /* get next state from compressed table */
  1210.  
  1211.         while ( c[b[yy_curst] + yy_sym] != yy_curst )
  1212.         {
  1213.         yy_curst = d[yy_curst];
  1214.  
  1215. #ifdef FLEX_USE_MECS
  1216.         /* we've arrange it so that templates are never chained
  1217.          * to one another.  This means we can afford make a
  1218.          * very simple test to see if we need to convert to
  1219.          * yy_sym's meta-equivalence class without worrying
  1220.          * about erroneously looking up the meta-equivalence
  1221.          * class twice
  1222.          */
  1223.  
  1224.         if ( yy_curst >= YY_TEMPLATE )
  1225.             yy_sym = m[yy_sym];
  1226. #endif
  1227.         }
  1228.  
  1229.         yy_curst = n[b[yy_curst] + yy_sym];
  1230.  
  1231. #endif
  1232.  
  1233.         yy_st_buf[yy_c_buf_p] = yy_curst;
  1234.  
  1235.         }
  1236. #ifdef FLEX_INTERACTIVE_SCANNER
  1237.     while ( b[yy_curst] != YY_JAM_BASE );
  1238. #else
  1239.     while ( yy_curst != YY_JAM );
  1240.     --yy_c_buf_p; /* put back character we jammed on */
  1241.  
  1242. #endif
  1243.  
  1244.     if ( yy_c_buf_p >= yy_b_buf_p )
  1245.         { /* we matched some text */
  1246.         yy_curst = yy_st_buf[yy_c_buf_p];
  1247.         yy_lp = l[yy_curst];
  1248.  
  1249. #ifdef FLEX_REJECT_ENABLED
  1250. find_rule: /* we branch to this label when doing a REJECT */
  1251. #endif
  1252.  
  1253.         for ( ; ; ) /* until we find what rule we matched */
  1254.         {
  1255. #ifdef FLEX_REJECT_ENABLED
  1256.         if ( yy_lp && yy_lp < l[yy_curst + 1] )
  1257.             {
  1258.             yy_act = a[yy_lp];
  1259.             goto do_action; /* "continue 2" */
  1260.             }
  1261. #else
  1262.         if ( yy_lp )
  1263.             {
  1264.             yy_act = yy_lp;
  1265.             goto do_action; /* "continue 2" */
  1266.             }
  1267. #endif
  1268.  
  1269.         if ( --yy_c_buf_p < yy_b_buf_p )
  1270.             break;
  1271.  
  1272.         yy_curst = yy_st_buf[yy_c_buf_p];
  1273.         yy_lp = l[yy_curst];
  1274.         }
  1275.         }
  1276.  
  1277.     /* if we got this far, then we didn't find any accepting
  1278.      * states
  1279.      */
  1280.  
  1281.     /* so that the default applies to the first char read */
  1282.     ++yy_c_buf_p;
  1283.  
  1284.     yy_act = YY_DO_DEFAULT;
  1285.     }
  1286.     }
  1287.  
  1288.     /*NOTREACHED*/
  1289.     }
  1290.  
  1291.  
  1292. static int unput( c )
  1293. char c;
  1294.  
  1295.     {
  1296.     YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  1297.  
  1298.     if ( yy_c_buf_p == 0 )
  1299.     {
  1300.     register int i;
  1301.     register int yy_buf_pos = YY_BUF_MAX;
  1302.  
  1303.     for ( i = yy_e_buf_p; i >= yy_c_buf_p; --i )
  1304.         {
  1305.         yy_ch_buf[yy_buf_pos] = yy_ch_buf[i];
  1306.         yy_st_buf[yy_buf_pos] = yy_st_buf[i];
  1307.         --yy_buf_pos;
  1308.         }
  1309.  
  1310.     yy_c_buf_p = YY_BUF_MAX - yy_e_buf_p;
  1311.     yy_e_buf_p = YY_BUF_MAX;
  1312.     }
  1313.  
  1314.     if ( yy_c_buf_p <= 0 )
  1315.     YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1316.  
  1317.     if ( yy_c_buf_p >= yy_b_buf_p && yy_ch_buf[yy_c_buf_p] == '\n' )
  1318.     yy_ch_buf[yy_c_buf_p - 1] = '\n';
  1319.  
  1320.     yy_ch_buf[yy_c_buf_p--] = c;
  1321.  
  1322.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1323.     }
  1324.  
  1325.  
  1326. static int input()
  1327.  
  1328.     {
  1329.     int c;
  1330.  
  1331.     YY_DO_BEFORE_SCAN
  1332.  
  1333.     if ( yy_c_buf_p == yy_e_buf_p )
  1334.     { /* need more input */
  1335.     int yy_n_chars;
  1336.  
  1337.     /* we can throw away the entire current buffer */
  1338.     if ( yy_saw_eof )
  1339.         {
  1340.         if ( yywrap() )
  1341.         return ( EOF );
  1342.  
  1343.         YY_INIT;
  1344.         }
  1345.  
  1346.     yy_b_buf_p = 0;
  1347.     YY_INPUT( yy_ch_buf, yy_n_chars, YY_MAX_LINE );
  1348.  
  1349.     if ( yy_n_chars == YY_NULL )
  1350.         {
  1351.         yy_saw_eof = 1;
  1352.  
  1353.         if ( yywrap() )
  1354.         return ( EOF );
  1355.  
  1356.         YY_INIT;
  1357.  
  1358.         return ( input() );
  1359.         }
  1360.  
  1361.     yy_c_buf_p = -1;
  1362.     yy_e_buf_p = yy_n_chars - 1;
  1363.     }
  1364.  
  1365.     c = yy_ch_buf[++yy_c_buf_p];
  1366.  
  1367.     YY_DO_BEFORE_ACTION;
  1368.  
  1369.     return ( c & BYTEMASK);
  1370.     }
  1371. # line 392 "scan.l"
  1372.  
  1373.